在建立通信连接的每一端，进程间的传输要有两个标志：


　　IP地址和端口号，合称为套接字地址 socket address


　　客户机套接字地址定义了一个唯一的客户进程


　　服务器套接字地址定义了一个唯一的服务器进程

　　套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。

　　Socket:套接字，进程间通信IPC的一种实现，允许位于不同主机（或同一主机）上不同进程之间进行通信和数据交换，SocketAPI出现于1983年，4.2 BSD实现。

　　Socket API：封装了内核中所提供的socket通信相关的系统调用。

　　Python中提供了socket标准库，非常底层的接口库。

AF表示Address Family，用于socket()第一个参数

　　AF_INET:

　　　　对应IPV4

　　AF_INET6

　　　　对应IPV6

　　AF_UNIX

　　　　同一主机不同进程之间通信时使用，对应Unix Domain Socket，windows没有。

SOCK_STREAM

　　可靠的传递，面向连接的流套接字。默认值，TCP协议。

SOCK_DGRAM

　　不可靠的传递，无连接的数据报文套接字。UDP协议。
SOCK_RAW: 
　　裸套接字,无须tcp或udp,APP直接通过IP包通信

　　Socket编程，需要两端，一般来说需要一个服务端、一个客户端，服务端称为Server，客户端称为Client。 这种编程模式也称为C/S编程。

　　套接字相关的系统调用：

　　　　socket(): 创建一个套接字

　　　　bind()： 绑定IP和端口

　　　　listen()： 监听

　　　　accept()： 接收请求

　　　　connect()： 请求连接建立

　　　　write()： 发送

　　　　read()： 接收

　　　　close(): 关闭连接

　　socket.recv(bufsize[, flags])

　　　　获取数据。默认是阻塞的方式


　　socket.recvfrom(bufsize[, flags])

　　　　获取数据，返回一个二元组(bytes, address)


　　socket.recv_into(buffer[, nbytes[, flags]])

　　　　获取到nbytes的数据后，存储到buffer中。如果 nbytes没有指定或0，将buffer大小的数据存入buffer中。返回接收的字节数。


　　socket.recvfrom_into(buffer[, nbytes[, flags]])

　　　　获取数据，返回一个二元组(bytes, address)到buffer中


　　socket.send(bytes[, flags])

　　　　TCP发送数据


　　socket.sendall(bytes[, flags])

　　　　TCP发送全部数据，成功返回None


　　socket.sendto(string[,flag],address)

　　　　UDP发送数据


　　socket.sendfile(file, offset=0, count=None)

　　　　python 3.5版本开始，发送一个文件直到EOF，使用高性能的os.sendfile机制，返回发送的字节数。如果win下不支持sendfile， 或者不是普通文件，使用send()发送文件。offset告诉 起始位置。

　　socket.getpeername()

　　　　返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)


　　socket.getsockname()

　　　　返回套接字自己的地址。通常是一个元组(ipaddr,port)


　　socket.setblocking(flag)

　　　　如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式(默认值)，非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常


　　socket.settimeout(value)

　　　　设置套接字操作的超时期，timeout是一个浮点数，单位是 秒。值为None表示没有超时期。一般，超时期应该在刚创 建套接字时设置，因为它们可能用于连接的操作(如 connect())


　　socket.setsockopt(level,optname,value)

　　　　设置套接字选项的值。比如缓冲区大小。太多了，去看文档。不同系统，不同版本都不尽相同

　　socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None)

　　　　创建一个与该套接字相关连的文件对象，将recv方法看做读方法，将send方法看做写方法。

　　创建Socket对象 

　　绑定IP地址Address和端口Port。bind()方法

　　　　IPv4地址为一个二元组('IP地址字符串', Port) 开始监听，将在指定的IP的端口上监听。listen()方法

　　获取用于传送数据的Socket对象

　　　　socket.accept() -> (socket object, address info)

　　　　　　accept方法阻塞等待客户端建立连接，返回一个新的Socket对象和客户端地址的二元组 地址是远程客户端的地址，IPv4中它是一个二元组(clientaddr, port)

　　　　　　接收数据

　　　　　　　　recv(bufsize[, flags]) 使用缓冲区接收数据

　　　　　　发送数据

　　　　　　　　send(bytes)发送数据

　　Server端开发

　　　　socket对象 --> bind((IP, PORT)) --> listen --> accept --> close

       　　　　                                           |--> recv or send --> close

 #！/usr/bin/env python

 #_*_conding:utf-8_*_

 #@author :yinzhengjie

 #blog:http://www.cnblogs.com/yinzhengjie

 import logging

 import socket

 import threading

 import datetime

 logging.basicConfig(level=logging.INFO, format="%(asctime)s %(thread)d %(message)s")

 """

     注意，这个代码为实验用，代码中瑕疵还有很多。Socket太底层了，实际开发中很少使用这么底层的接 口。

 """

 class ChatServer:

     def __init__(self,ip="127.0.0.1",port=6666):

         self.conn = socket.socket()         #创建socket对象

         self.addr = (ip,port)

         self.clients = {}                   #存放客户端连接容器

         self.event = threading.Event()      #判断服务是否启动

         self.lock = threading.Lock()        #为了线程安全而引入的

     def start(self):                        #启动服务,会监听IP地址和端口哟～

         self.conn.bind(self.addr)           #将IP地址和端口绑定到套接字上

         self.conn.listen()                  #监听绑定的套接字

         #accept会阻塞主线程，所以开一个新线程

         threading.Thread(target=self.accept).start()

     def accept(self):                               #处理客户端的链接

         while not self.event.is_set():

             conn,client = self.conn.accept()        #该方法默认会进入阻塞状态

             f = conn.makefile("rw")                 #将socket封装成一个文件对象来操作，支持读写

             with self.lock:

                 self.clients[client] = f,conn       #如果有新链接就添加到客户端字典

             #准备接收数据，recv是阻塞的，开启新的线程

             threading.Thread(target=self.recv,args=(f,client)).start()

     def recv(self,f,client):                        #处理客户端数据

         print("in recv")

         while not self.event.is_set():

             try:

                 data = f.readline()

                 print(data)

             except Exception as e:

                 logging.error(e)

                 data = "quit"

             msg = data.strip()

             print(msg, "++++++++++++++++++")

             #和客户端约定退出命令

             if msg == "quit" or msg == "":           #主动端口得到空串

                 with self.lock:

                     _,conn = self.clients.pop(client)

                     f.close()

                     conn.close()

                 logging.info("{} quit ...".format(client))

                 break

             msg = "{:%Y/%m/%d %H:%M:%S} ip:port => {}:{}\n data => {}\n".format(datetime.datetime.now(),*client, data)

             logging.info(msg)

             with self.lock:

                 for f1,_ in self.clients.values():

                     f1.write(msg)

                     f1.flush()

     def stop(self):                         #停止服务

         self.event.set()

         with self.lock:

             for f,s in self.clients.values():

                 f.close()

                 s.close()

         self.conn.close()

 def main():

     server = ChatServer()

     server.start()

     while True:

         cmd = input(">>> ").strip()

         if cmd == "quit":

             server.stop()

             threading.Event.wait(3)                 #关闭服务需要等待时间

             break

         logging.info(threading.enumerate())         #用来观察断开后线程的变化

         logging.info(server.clients)

 if __name__ == '__main__':

     main()

　　创建Socket对象 

　　连接到远端服务端的ip和port，connect()方法 

　　传输数据　　

　　　　使用send、recv方法发送、接收数据 

　　关闭连接，释放资源

 #！/usr/bin/env python

 #_*_conding:utf-8_*_

 #@author :yinzhengjie

 #blog:http://www.cnblogs.com/yinzhengjie

 import socket

 import threading

 import datetime

 import logging

 FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"

 logging.basicConfig(format=FORMAT, level=logging.INFO)

 """

     同样，这样的客户端还是有些问题的，仅用于测试。

 """

 class ChatClient:

     def __init__(self, ip='127.0.0.1', port=6666):

         self.sock = socket.socket()

         self.addr = (ip, port)

         self.event = threading.Event()

     def start(self): # 启动对远端服务器的连接

         self.sock.connect(self.addr)

         self.send("I'm ready.")

         # 准备接收数据，recv是阻塞的，开启新的线程

         threading.Thread(target=self.recv, name="recv").start()

     def recv(self): # 接收服务端的数据

         while not self.event.is_set():

             try:

                 data = self.sock.recv(1024) # 阻塞

             except Exception as e:

                 logging.error(e)

                 break

             msg = "{:%Y/%m/%d %H:%M:%S} ip:port => {}:{}\n data => {}\n".format(datetime.datetime.now(),*self.addr, data.strip())

             logging.info(msg)

     def send(self, msg:str):

         data = "{}\n".format(msg.strip()).encode() # 服务端需要一个换行符

         self.sock.send(data)

     def stop(self):

         self.sock.close()

         self.event.wait(3)

         self.event.set()

         logging.info('Client stops...')

 def main():

     client = ChatClient()

     client.start()

     while True:

         cmd = input('>>>')

         if cmd.strip() == 'quit':

             client.stop()

             break

         client.send(cmd) # 发送消息

 if __name__ == '__main__':

     main()