Python网络编程

py3study

发布于 2020-01-15 22:59:59

7530

发布于 2020-01-15 22:59:59

文章被收录于专栏：python3python3

网络编程

# notes 要点网络编程

客户端/服务器架构

客户端/服务器网络编程

套接字是计算机网络数据结构。在任何类型的通信开始之前，网络应用程序必须创建套接字。可以将它们比作电话插孔，没有它将无法进行通信。

进程间通信(Inter Process Communication)

地址家族(address family): UNIX套接字: AF_UNIX (基于文件) INET套接字: AF_INET (基于网络)（因特网）套接字地址:主机-端口对

面向连接的套接字:通信之前必须先建立一个连接(提供序列化的、可靠的和不重复的数据交付，而没有记录边界) 实现这种连接类型的主要协议是传输控制协议(Transmission Control Protocol)(TCP) 为了创建TCP套接字，必须使用SOCK_STREAM作为套接字类型

无连接的套接字：在通信开始前不需要建立连接(无法保证顺序性、可靠性或重复性) 实现这种连接类型的主要协议是用户数据报协议(User Datagram Protocol)(UDP) 为了创建UDP套接字，必须哈斯用SOCK_DGRAM作为套接字类型

# sock.py python中的网络编程-socket篇

# 要创建套接字，必须使用socket.socket(socket_family, socket_type, protocol=0)
# socket_family 地址家族 AF_UNIX或AF_INET 
# socket_type 套接字类型 SOCK_STREAM或SOCK_DGRAM
# protocol通常省略，默认为0

# 为了创建TCP/IP套接字
# tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

# 为了创建UDP/IP套接字
# udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

# 套接字对象(内置)方法
# 服务器套接字方法
# s.bind()        将地址(主机名，端口号对)绑定到套接字上
# s.listen()    设置并启动TCP监听器
# s.accept()    被动接受TCP客户端链接，一直等待直到连接到达(阻塞)

# 客户端套接字方法
# s.connect()    主动发起TCP服务器连接
# s.connect_ex()扩展版本，以错误码形式返回问题，而不是抛出一个异常

# 普通的套接字方法
# s.recv()        接受TCP信息
# s.recv_into()    接受TCP信息到指定的缓冲区
# s.send()         发送TCP信息
# s.sendall()    完整地发送TCP信息

# 创建TCP服务器
# ss = socket()             创建服务器套接字
# ss.bind()                    套接字与地址绑定
# ss.listen()                监听连接
# inf_loop:                    服务器无限循环
#     cs = ss.accept()        接受客户端连接(返回客户端套接字)
#     comm_loop:                通信循环
#         cs.recv()/cs.send() 对话(接受/发送)
#     cs.close()                关闭客户端套接字
# ss.close()                关闭服务器套接字

# 创建TCP客户端
# cs = socket()                创建客户端套接字
# cs.connect()                尝试连接服务器
# comm_loop:                通信循环
#     cs.send()/cs.recv()        对话(发送/接受)
# cs.close()                关闭客户端套接字

# 创建UDP服务器
# ss = socket()                创建服务器套接字
# ss.bind()                    绑定服务器套接字
# inf_loop():                服务器无线循环
#     cs = ss.recvfrom()/ss.sendto()    # 关闭(接受/发送)
# ss.close()

# 创建UDP客户端
# cs = socket()                创建客户端套接字
# comm_loop:                通信循环
#     cs.sendto()/cs.recvfrom()    对话(发送/接受)
# cs.close()                关闭客户端套接字

# tcpServer.py TCP服务端
#!/usr/bin/env python

from socket import *
from time import ctime

HOST = ''              # 主机名
PORT = 31416        # 端口
BUFSIZ = 1024        # 缓冲大小
ADDR = (HOST, PORT) # 套接字地址(主机名，端口)

tcpSerSock = socket(AF_INET, SOCK_STREAM)  # 创建套接字
tcpSerSock.bind(ADDR)  # 套接字与地址绑定
tcpSerSock.listen(5)  # 监听

try:
    while True:
        print('waiting for connection...')
        tcpCliSock, addr = tcpSerSock.accept()  # 阻塞，等待连接，返回客户端套接字与套接字地址(主机名，端口)
        print('...connected from:', addr)

        while True:
            data = tcpCliSock.recv(BUFSIZ)
            if not data:
                break
            reply = '[%s] %s' % (ctime(), data.decode('utf-8'))
            tcpCliSock.send(bytes(reply, 'utf-8'))
        tcpCliSock.close()
    tcpSerSock.close()
except KeyboardInterrupt:
    print('Bye!')

# tcpClient.py TCP客户端
#!/usr/bin/env python

from socket import *

HOST = 'localhost' # or 'localhost'
PORT = 31416
BUFSIZ = 1024
ADDR = (HOST, PORT)

tcpCliSock = socket(AF_INET, SOCK_STREAM)
tcpCliSock.connect(ADDR)

while True:
    data = input('> ')
    if not data:
        break
    tcpCliSock.send(bytes(data, 'utf-8'))
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))

tcpCliSock.close()

# udpServer.py UDP服务端
#!/usr/bin/env python

from socket import *
from time import ctime

HOST = ''
PORT = 31416
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpSerSock = socket(AF_INET, SOCK_DGRAM)
udpSerSock.bind(ADDR)

try:
    while True:
        print('waiting for massage...')
        data, addr = udpSerSock.recvfrom(BUFSIZ)
        reply = '[%s]: %s' % (ctime(), data.decode('utf-8'))
        udpSerSock.sendto(bytes(reply, 'utf-8'), addr)
        print('...received from and returned to:', addr)
except KeyboardInterrupt:
    print('Bye!')

udpSerSock.close()

# udpClient.py UDP客户端
#!/usr/bin/env python

from socket import *

HOST = 'localhost'
PORT = 31416
BUFSIZ = 1024
ADDR = (HOST, PORT)

udpCliSock = socket(AF_INET, SOCK_DGRAM)

while True:
    data = input('> ')
    if not data:
        break
    udpCliSock.sendto(bytes(data, 'utf-8'), ADDR)
    data, ADDR = udpCliSock.recvfrom(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8'))

udpCliSock.close()

# tcpSocketServer.py SocketServerTCP服务器
#!/usr/bin/env python

from socketserver import (TCPServer as TCP, StreamRequestHandler as SRH)
from time import ctime

HOST = ''
PORT = 31416
ADDR = (HOST, PORT)

class MyRequestHandler(SRH):
    def handle(self):
        print('...connected from:', self.client_address)
        reply = '[%s] %s' % (ctime(), self.rfile.readline().decode('utf-8'))
        self.wfile.write(bytes(reply, 'utf-8'))

tcpServ = TCP(ADDR, MyRequestHandler)
print('waiting for connection...')
tcpServ.serve_forever()

# tcpSocketClient.py SocketServerTCP客户端
#!/usr/bin/env python

from socket import *

HOST = 'localhost'
PORT = 31416
BUFSIZ = 1024
ADDR = (HOST, PORT)

while True:
    # socketserver处理程序的默认行为是接受连接、获取请求，然后关闭连接，所以，每次都要新建一个套接字    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    tcpCliSock.connect(ADDR)
    data = input('> ')
    if not data:
        break
    reply = '%s\r\n' % data
    tcpCliSock.send(bytes(reply, 'utf-8'))  # 因为这里使用的处理程序类对待套接字通信就像文件一样，所以必须发送终止符(回车和换行符)
    data = tcpCliSock.recv(BUFSIZ)
    if not data:
        break
    print(data.decode('utf-8').strip())
    tcpCliSock.close()