Python—网络编程_TCP/UDP

网络编程

• 网络：

• 网络协议： 一套规则

• 网络模型：

  • 七层模型-七层
    • 物理层
    • 数据链路层
    • 网络层
    • 传输层
    • 会话层
    • 表示层
    • 应用层
  • 四层模型-实际应用
    • 链路层
    • 网络
    • 传输层
    • 应用层

• 每一层都有相应的协议负责交换信息或者协同工作

• TCP/IP 协议族

• IP地址：负责在网络上唯一定位一个机器

  • IP地址分ABCDE类
  • 是由四个数字段组成，每个数字段的取值是0-255
  • 192.168.xxx.xxx:局域网ip
  • 127.0.0.1：本机
  • IPv4, IPv6

• 端口

  • 范围： 0-65535
    • 知名端口：0-1023
    • 非知名端口：1024-

TCP/UDP协议

• UDP：非安全的不面向链接的传输

  • 安全性差
  • 大小限制64kb
  • 没有顺序
  • 速度快

• TCP

  • 基于链接的通信

• SOCKET编程

  • socket（套接字）: 是一个网络通信的端点， 能实现不同主机的进程通信，网络大多基于Socket通信
  • 通过IP+端口定位对方并发送消息的通信机制
  • 分为UDP和TCP
  • 客户端Client： 发起访问的一方
  • 服务器端Server：接受访问的一方

• UDP 编程

  • Server端流程
    1. 建立socket，socket是负责具体通信的一个实例
    2. 绑定，为创建的socket指派固定的端口和ip地址
    3. 接受对方发送内容
    4. 给对方发送反馈，此步骤为非必须步骤
  • Client端流程
    1. 建立通信的socket
    2. 发送内容到指定服务器
    3. 接受服务器给定的反馈内容
  • 服务器案例v01
  • 客户端案例v02
  • 服务器程序要求永久运行，一般用死循环处理
  • 改造的服务器版本v03

• TCP编程

  • 面向链接的传输，即每次传输之前需要先建立一个链接
  • 客户端和服务器端两个程序需要编写
  • Server端的编写流程
    1. 建立socket负责具体通信，这个socket其实只负责接受对方的请求，真正通信的是链接后从新建立的socket
    2. 绑定端口和地址
    3. 监听接入的访问socket
    4. 接受访问的socket，可以理解接受访问即建立了一个通讯的链接通路
    5. 接受对方的发送内容，利用接收到的socket接收内容
    6. 如果有必要，给对方发送反馈信息
    7. 关闭链接通路
  • Client端流程
    1. 建立通信socket
    2. 链接对方，请求跟对方建立通路
    3. 发送内容到对方服务器
    4. 接受对方的反馈
    5. 关闭链接通路
  • 案例v04， v05

**v01**
'''
Server端流程
 1. 建立socket，socket是负责具体通信的一个实例
 2. 绑定，为创建的socket指派固定的端口和ip地址
 3. 接受对方发送内容
 4. 给对方发送反馈，此步骤为非必须步骤
'''


# socket模块负责socket编程
import socket

# 模拟服务器的函数
def serverFunc():
    # 1. 建立socket

    # socket.AF_INET:使用ipv4协议族
    # socket.SOCK_DGRAM: 使用UDP通信
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # 2. 绑定ip和port
    # 127.0.0.1: 这个ip地址代表的是机器本身
    # 7852： 随手指定的端口号
    # 地址是一个tuple类型，(ip, port)
    addr = ("127.0.0.1", 7852 )
    sock.bind( addr )


    # 接受对方消息
    # 等待方式为死等， 没有其他可能性
    # recvfrom接受的返回值是一个tuple，前一项表示数据，后一项表示地址
    # 参数的含义是缓冲区大小
    # rst = sock.recvfrom(500)
    data, addr = sock.recvfrom(500)

    print(data)
    print(type(data))

    # 发送过来的数据是bytes格式，必须通过解码才能得到str格式内容
    # decode默认参数是utf8
    text = data.decode()
    print(type(text))
    print(text)


    # 给对方返回的消息
    rsp = "Ich hab keine Hunge"

    # 发送的数据需要编码成bytes格式
    # 默认是utf8
    data = rsp.encode()
    sock.sendto(data, addr)


if __name__ == '__main__':
    print("Starting server.........")
    serverFunc()
    print("Ending server........")

**v02**
import socket

'''
- Client端流程
            1. 建立通信的socket
            2. 发送内容到指定服务器
            3. 接受服务器给定的反馈内容
'''


def clientFunc():

    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)


    text = "I love jingjing"

    # 发送的数据必须是bytes格式
    data = text.encode()

    # 发送
    sock.sendto(data,  ("127.0.0.1", 7852))


    data, addr  = sock.recvfrom(200)

    data = data.decode()

    print(data)


if __name__ == '__main__':
    clientFunc()

**v03**

# socket模块负责socket编程
import socket

# 模拟服务器的函数
def serverFunc():
    # 1. 建立socket

    # socket.AF_INET:使用ipv4协议族
    # socket.SOCK_DGRAM: 使用UDP通信
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

    # 2. 绑定ip和port
    # 127.0.0.1: 这个ip地址代表的是机器本身
    # 7852： 随手指定的端口号
    # 地址是一个tuple类型，(ip, port)
    addr = ("127.0.0.1", 7852 )
    sock.bind( addr )


    # 接受对方消息
    # 等待方式为死等， 没有其他可能性
    # recvfrom接受的返回值是一个tuple，前一项表示数据，后一项表示地址
    # 参数的含义是缓冲区大小
    # rst = sock.recvfrom(500)
    data, addr = sock.recvfrom(500)

    print(data)
    print(type(data))

    # 发送过来的数据是bytes格式，必须通过解码才能得到str格式内容
    # decode默认参数是utf8
    text = data.decode()
    print(type(text))
    print(text)


    # 给对方返回的消息
    rsp = "Ich hab keine Hunge"

    # 发送的数据需要编码成bytes格式
    # 默认是utf8
    data = rsp.encode()
    sock.sendto(data, addr)


if __name__ == '__main__':
    import time
    while 1:
        try:
            serverFunc()
        except Exception as e:
            print(e)

        time.sleep(1)

**v04**
import socket


def  tcp_srv():
    # 1. 建立socket负责具体通信，这个socket其实只负责接受对方的请求，真正通信的是链接后从新建立的socket
    # 需要用到两个参数
    # AF_INET: 含义同udp一致
    # SOCK_STREAM: 表明是使用的tcp进行通信
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 绑定端口和地址
    # 此地址信息是一个元祖类型内容，元祖分两部分，第一部分为字符串，代表ip，第二部分为端口，是一个整数，推荐大于10000
    addr = ("127.0.0.1", 8998)
    sock.bind(addr)
    # 3. 监听接入的访问socket
    sock.listen()

    while True:
        # 4. 接受访问的socket，可以理解接受访问即建立了一个通讯的链接通路
        # accept返回的元祖第一个元素赋值给skt，第二个赋值给addr
        skt,addr = sock.accept()
        # 5. 接受对方的发送内容，利用接收到的socket接收内容
        # 500代表接收使用的buffersize
        #msg = skt.receive(500)
        msg = skt.recv(500)
        # 接受到的是bytes格式内容
        # 想得到str格式的，需要进行解码
        msg = msg.decode()

        rst = "Received msg: {0} from {1}".format(msg, addr)
        print(rst)
        # 6. 如果有必要，给对方发送反馈信息
        skt.send(rst.encode())

        # 7. 关闭链接通路
        skt.close()


if __name__ == "__main__":
    print("Starting tcp server.......")
    tcp_srv()
    print("Ending tcp server.......")

**v05**
import socket

def tcp_clt():
    # 1. 建立通信socket
    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    # 2. 链接对方，请求跟对方建立通路
    addr = ("127.0.0.1", 8998)
    sock.connect(addr)
    # 3. 发送内容到对方服务器
    msg = "I love wangxiaojing"
    sock.send(msg.encode())
    # 4. 接受对方的反馈
    rst =  sock.recv(500)
    print(rst.decode())
    # 5. 关闭链接通路
    sock.close()


if __name__ == "__main__":
    tcp_clt()