python网络编程

前言：网络编程主要分成udp和tcp两种，udp不需要创建连接，所以传输速度快，但不稳健，tcp需要创建连接，所以传输速度慢，但稳健，现在，大多数应用都采用tcp来进行通信。

一、UDP

　　1.send端

　　　　1)导包 from socket import *

　　　　2)创建udpSocket对象，udpSocket = socket(AF_INET,SOCK_DGREAM)

　　　　3)调用对象发送消息，udpSocket.sendto("hello,udp,我来了".encode("utf-8"),("你要发送的那台机器的ip地址",端口))

　　　　4)关闭udpSocket对象，udpSocket.close()

　　2.recive端

　　　　1)导包 from socket import *

　　　　2)创建udpSocket对象，udpSocket = socket(AF_INET,SOCK_DGREAM)

　　　　3)绑定ip和端口，udpSocket.bind(("你要接收的那台机器的ip地址",端口))

　　　　4)接收数据，udpSocket.recvfrom(1024)

　　　　5)关闭udpSocket对象，udpSocket.close()

　　

from socket import *

udpSocket = socket(AF_INET,SOCK_DGRAM)
#使用udp发送的数据，在每一次的都需要写上接收方的ip和port，可以告诉接收方用什么方式编码
udpSocket.sendto("haha
".encode("gb2312"),("172.25.6.222",8080))

udpSocket.sendto("你好啊".encode("utf-8"),("202.193.52.52",1880))

　　

#coding = utf-8

from socket import *
udpSocket = socket(AF_INET,SOCK_DGRAM)

udpSocket.bind(('',8080))
recvData = udpSocket.recvfrom(1024)
print(recvData[0].decode("utf-8"))

二、TCP

　　1.server端

　　　　1)导包 from socket import *

　　　　2)创建tcpSocket对象，tcpSocket = socket(AF_INET,SOCK_STREAM)

　　　　3)绑定ip和端口，tcpSocket.bind("server端的ip",端口)

　　　　4)监听，tcpSocket.listen(5)

　　　　5)接收client端，clientSocket,clientInfo = tcpSocket.accept()

　　　　6)将client端的请求信息进行打印，recvData = clientSocket.recv(1024),print(recvData)

　　2.client端

　　　　1)导包 from socket import *

　　　　2)创建tcpSocket对象，tcpSocket = socket(AF_INET,SOCK_STREAM)

　　　　3)连接server端，tcpSocket.connect("server的ip地址"，端口)

　　　　4)向server端发送数据，clientSocket.send("hello,tcp,我来了".encode("utf-8"))

　　　　5)将server端返回的信息进行打印，recvData = clientSocket.recv(1024),print(recvData)

　　　　6）关闭客户端，clientSocket.close()

　　

from socket import *

serverSocket = socket(AF_INET, SOCK_STREAM)

serverSocket.bind(("", 8899))

serverSocket.listen(5)

print("-----1-----")
clientSocket,clientInfo = serverSocket.accept()

print("-----2-----")
#clientSocket 表示这个新的客户端
#clientInfo 表示这个新的客户端的ip以及port

recvData = clientSocket.recv(1024)

print("-----3-----")
print("%s:%s"%(str(clientInfo), recvData))

clientSocket.close()
serverSocket.close()

　　

from socket import *

clientSocket = socket(AF_INET, SOCK_STREAM)
clientSocket.connect(("192.168.119.153", 8989))

#注意：
# 1. tcp客户端已经链接好了服务器，所以在以后的数据发送中，不需要填写对方的iph和port----->打电话
# 2. udp在发送数据的时候，因为没有之前的链接，所依需要　在每次的发送中　都要填写接收方的ip和port－－－－－＞写信　
clientSocket.send("haha".encode("gb2312"))

recvData = clientSocket.recv(1024)

print("recvData:%s"%recvData)

clientSocket.close()

 三、单进程服务器　　　

　　

四、多进程服务器

　　

from socket import *
from multiprocessing import *
from time import sleep

# 处理客户端的请求并为其服务
def dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if len(recvData)>0:
            print('recv[%s]:%s'%(str(destAddr), recvData))
        else:
            print('[%s]客户端已经关闭'%str(destAddr))
            break

    newSocket.close()


def main():

    serSocket = socket(AF_INET, SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
    localAddr = ('', 7788)
    serSocket.bind(localAddr)
    serSocket.listen(5)

    try:
        while True:
            print('-----主进程，，等待新客户端的到来------')
            newSocket,destAddr = serSocket.accept()

            print('-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----'%str(destAddr))
            client = Process(target=dealWithClient, args=(newSocket,destAddr))
            client.start()

            #因为已经向子进程中copy了一份（引用），并且父进程中这个套接字也没有用处了
            #所以关闭
            newSocket.close()
    finally:
        #当为所有的客户端服务完之后再进行关闭，表示不再接收新的客户端的链接
        serSocket.close()

if __name__ == '__main__':
    main()

五、多线程服务器

　　

#coding=utf-8
from socket import *
from threading import Thread
from time import sleep

# 处理客户端的请求并执行事情
def dealWithClient(newSocket,destAddr):
    while True:
        recvData = newSocket.recv(1024)
        if len(recvData)>0:
            print('recv[%s]:%s'%(str(destAddr), recvData))
        else:
            print('[%s]客户端已经关闭'%str(destAddr))
            break

    newSocket.close()


def main():

    serSocket = socket(AF_INET, SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
    localAddr = ('', 7788)
    serSocket.bind(localAddr)
    serSocket.listen(5)

    try:
        while True:
            print('-----主进程，，等待新客户端的到来------')
            newSocket,destAddr = serSocket.accept()

            print('-----主进程，，接下来创建一个新的进程负责数据处理[%s]-----'%str(destAddr))
            client = Thread(target=dealWithClient, args=(newSocket,destAddr))
            client.start()

            #因为线程中共享这个套接字，如果关闭了会导致这个套接字不可用，
            #但是此时在线程中这个套接字可能还在收数据，因此不能关闭
            #newSocket.close() 
    finally:
        serSocket.close()

if __name__ == '__main__':
    main()

六、单进程服务器-非堵塞模式

　　

#coding=utf-8
from socket import *
import time

# 用来存储所有的新链接的socket
g_socketList = []

def main():
    serSocket = socket(AF_INET, SOCK_STREAM)
    serSocket.setsockopt(SOL_SOCKET, SO_REUSEADDR  , 1)
    localAddr = ('', 7788)
    serSocket.bind(localAddr)
    #可以适当修改listen中的值来看看不同的现象
    serSocket.listen(1000)
    #将套接字设置为非堵塞
    #设置为非堵塞后，如果accept时，恰巧没有客户端connect，那么accept会
    #产生一个异常，所以需要try来进行处理
    serSocket.setblocking(False)

    while True:

        #用来测试
        #time.sleep(0.5)

        try:
            newClientInfo = serSocket.accept()
        except Exception as result:
            pass
        else:
            print("一个新的客户端到来:%s"%str(newClientInfo))
            newClientInfo[0].setblocking(False)
            g_socketList.append(newClientInfo)

        # 用来存储需要删除的客户端信息
        needDelClientInfoList = []

        for clientSocket,clientAddr in g_socketList:
            try:
                recvData = clientSocket.recv(1024)
                if len(recvData)>0:
                    print('recv[%s]:%s'%(str(clientAddr), recvData))
                else:
                    print('[%s]客户端已经关闭'%str(clientAddr))
                    clientSocket.close()
                    g_needDelClientInfoList.append((clientSocket,clientAddr))
            except Exception as result:
                pass

        for needDelClientInfo in needDelClientInfoList:
            g_socketList.remove(needDelClientInfo)

if __name__ == '__main__':
    main()