什么是socket
socket(套接字)是进程间通信的一种方式，它与其他进程间通信的一个主要不同是：他能实现不同主机间的进程间通信，我们网络上各种各样的服务大多都是基于Socket来完成的

在Python中使用socket模块的函数socket就可以完成
import socket
socket.socket(AddressFamily,Type)
说明：
Address Family：可以选择 AF_INET（用于 Internet 进程间通信） 或者 AF_UNIX（用于同一台机器进程间通信）,实际工作中常用AF_INET
Type：套接字类型，可以是 SOCK_STREAM（流式套接字，主要用于 TCP 协议）或者 SOCK_DGRAM（数据报套接字，主要用于 UDP 协议）
创建一个tcp socket(tcp套接字)
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print 'Socket Created'
创建一个udp socket（udp套接字）
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
print 'Socket Created'

UDP和TCP区别
UDP在通信开始之前，不需要建立相关的连接，只要发送数据即可，类似于生活中"写信"，写上对方IP和端口即可通信
TCP在通信开始之前，一定要先建立相关的连接，才能发送数据，类似于生活中的打电话，

TCP接收发送数据：send()接收，recv()发送
UDP接收发送数据：sendto()接收，recvfrom()发送

UDP介绍：
UDP只是把应用程序传给IP层的数据送出去，但是并不能保证它们能到达目的地，由于udp在传输数据前不用再客户和服务器之间建立一个链接，没有超时重发等机制，因此传输速度快，信息能否到达目的地，到达目的地时间以及能容的正确性都是不能被保证的

发送代码：
    from socket import *
    #创建套接字
    udpSocket = socket(AF_INET,SOCK_DGRAM)
    #准备对方的地址
    sendAddr = ('192.168.133.1',8080)
    #发送给对方的数据，byte
    dendData = b"haha"
    #发送到指定的电脑上
    udpSocket.sendto(dendData,sendAddr)
    #关闭套接字
    udpSocket.close()
发送等待接收代码：
    from socket import *
    #创建套接字
    udpSocket = socket(AF_INET,SOCK_DGRAM)
    #绑定本地的相关信息，如果一个网络程序不绑定，则系统会随机分配
    bindAddr = ('',7788)
    udpSocket.bind(bindAddr)

    等待接收对方发送的数据
    recvData = udpSocket.recvfrom(1024) #1024表示本次接收的最大字节
    显示接收到的数据
    print(recvData[0].decode(),recvData[1])

        #第二种接收
        # a1,a2 = udpSocket.recvfrom(1024)
        # print('%s,%s'%(a1.decode(),a2))

    #关闭套接字
    udpSocket.close()

TCP流程：
1.socket创建一个套接字
2.bind绑定ip和port
3.listen使套接字变为可以被动链接
4.accept等待客户端的链接
5.recv/send接收发送数据

tcp服务器代码：
    from socket import *
    #创建tcp的socket
    tcpSerSocket = socket(AF_INET,SOCK_STREAM)
    #绑定本地信息
    address = ('',7788)
    tcpSerSocket.bind(address)

    #使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动，这样就可以接收别人的连接了
    tcpSerSocket.listen(5)
    #如果有新的客户端来连接服务器，那么就产生一个新的套接字专门为这个客户端服务
    #也就是新创建出来的套接字对象带有着两个信息，在这里就是拆包一下
    #tcpSerSocket就可以省下来专门等待其他新客户端的连接
    #newSocket用来为这个客户端服务，clientAddr表示这个新的客户端的ip以及端口
    newSocket,clientAddr = tcpSerSocket.accept()
    #接收对方发送过来的数据，最大接收1024个字节
    recvData = newSocket.recv(1024)
    #发送一些数据到客户端
    newSocket.send("thank you!")
    #关闭客户端套接字
    newSocket.close()
    #关闭监听套接字
    tcpSerSocket.close()
tcp客户端代码：
    from socket import *
    #创建socket
    tcpClientSocket = socket(AF_INET,SOCK_STREAM)
    #连接服务器
    serAddr = ('192.168.241.131',7788)
    tcpClientSocket.connect(serAddr)
    #发送的数据
    sendData = b"haha"
    tcpClientSocket.send(sendData)
    #接收对方发送过来的数据，最大接收1024个字节
    recvData = tcpClientSocket.recv(1024)
    print('接收到的数据为：%s'%recvData.decode())
    #关闭套接字
    tcpClientSocket.close()
QQ客户端：
    from socket import *
    #创建socket
    tcpclient = socket(AF_INET,SOCK_STREAM)
    #连接服务器
    serAddr = ('192.168.133.1',9997)
    tcpclient.connect(serAddr)
    while True:
        sendData=input('输入：')
        if len(sendData)>0:
            #发送数据
            tcpclient.send(sendData.encode("utf-8"))
        else:
            break
            #接收数据，最大接收1024个字节
        recvData = tcpclient.recv(1024)
        print('接收：%s'%recvData.decode('utf-8'))
    #关闭套接字
    tcpclient.close()
QQ服务端：
    #服务端
    from socket import *
    #创建tct的socket
    tcpser = socket(AF_INET,SOCK_STREAM)
    #tcpser.setsockopt(SOL_SOCKET,SO_REUSEADDR,1)
    #绑定本地信息
    address = ('',9997)
    tcpser.bind(address)

    #使用socket创建的套接字默认的属性是主动的，使用listen将其变为被动的，这样就可以接收别人的连接了
    tcpser.listen(5)
    while True:
        #如果有新的客户端来连接服务器，那么久产生一个新的套接字专门为这个客户端服务器
        #也就是新创建出来的套接字对象带有着两个信息，在这里就是拆包一下
        #tcpSerSocket就可以省下来专门等待其他新客户端的连接
        #newSocket用来为这个客户端服务，clientAddr表示这个新的客户端的ip以及端口
        newSocket,clientAddr = tcpser.accept()

        while True:
            #接收对方发送过来的数据，最大接收1024个字节
            recvData = newSocket.recv(1024)
            #如果接收的数据的长度为0,则意味着客户端关闭了连接
            if len(recvData)>0:
                print('接收：',recvData.decode('utf-8'))
            else:
                break
            #发送一些数据到客户端
            sendData = input('输入：')
            newSocket.send(sendData.encode('utf-8'))
        #关闭为这个客户端服务的套接字，只要关闭了，就意味着不能再为这个客户端服务了，如果还需要服务，只能再次重新连接
        newSocket.close()
    #关闭监听套接字，只要这个套接字关闭了，就意味着整个程序不能再接收任何新的客户端的连接
    tcpser.close()

总结：
from socket import *
UDP字段
1.socket创建一个套接字(SOCK_DGRAM)
2.发送方绑定ip并发送数据sendto(b‘信息‘，(‘ip‘,端口))
3.接收方绑定bind('',端口)
4.接收数据recvfrom(1024)最大接收1024字节，拆包：信息，ip端口
5.关闭套接字
发送：
1.udpsocket = socket(AF_INET,SOCK_DGRAM) #创建套接字
2.udpsocket.sendto(b'信息'，('ip',端口)) #发送数据到指定ip端口
3.udpsocket.close() #关闭套接字
接收：
2.udpsocket.bind('',端口) #绑定本地ip端口

拆包：a1是信息，a2是ip端口

a1,a2 = udpsocket.recvfrom(1024) #接收最大字节1024
print('%s,%s'%(a1.decode(),a2))

TCP字段：
1.socket创建一个套接字(SOCK_STREAM)
2.服务器绑定本地bind('',端口)
3.客户端连接服务器connect('ip',端口)
3.listen使套接字变为可以被动链接
4.accept等待客户端的链接，拆包：用来为客户端服务，这个客户度ip端口
5.接收数据recv(1024)最大接收1024字节
6.发送数据send('信息')
7.服务器关闭客户端套接字和接听套接字
8.客户端关闭套接字
客户端：
1.连接对方服务器connect('ip',端口)
2.发送数据send(b'信息')
3.接收数据recv(1024)接收最大1024字节
4.关闭套接字服务器close()
服务端：
1.绑定本地bind('',端口)
2.listen(5)套接字默认属性变为被动，接收客户端连接最大5个
3.创建新套接字为连接的客户端服务accept()，这里需要拆包
创建的新套接字有两个属性，1.用来为客户端服务，2.客户端的ip端口
4.新客户端套接字.recv(1024),接收信息
5.新客户端套接字.send('信息'),发送信息
6.新客户端套接字.close(),关闭客户端套接字
7.关闭套接字服务器close()